import {
  getFridgeIngredients,
  addIngredient,
  updateIngredient,
  deleteIngredient
} from '../../api/fridge'; // 引入封装的添加食材 API
import {
  store
} from '../../utils/store';
const app = getApp(); // 获取 app.js 的实例
Page({
  data: {
    categories: ['全部', '蔬菜', '肉类', '水果', '乳制品', '调味品'], // 原始分类
    filteredCategories: [], // 新增过滤后的分类数组
    selectedCategory: '全部', // 当前选中的分类
    ingredients: [], // 当前分类下的食材列表
    showAddIngredientModal: false, // 控制添加食材模态框的显示
    showEditIngredientModal: false, // 控制编辑食材模态框的显示
    isLoggedIn: false, // 表示登录状态
    showLoginModal: false, // 控制登录模态框的显示
    newIngredient: {
      name: '',
      category: '',
      categoryIndex: 0, // 默认选中第一个分类
      expiryDate: '',
      quantity: ''
    },
    editIngredient: { // 编辑食材数据
      itemId: '',
      name: '',
      category: '',
      categoryId: 0,
      expiryDate: '',
      quantity: ''
    },
    currentDate: '', // 当前日期
    current: 1, // 当前页码
    pageSize: 10, // 每页大小
    hasMore: true, // 是否有更多数据
    userId: '', // 将从store中获取
    hasShownExpiryAlert: false, // 添加标记，记录本次会话是否已显示过过期提醒
  },

  async onLoad(options) {
    await app.checkLoginStatus();

  },

  async onShow() {
    await app.checkLoginStatus();
    this.checkLoginStatus();
  },

  // 检查登录状态
  checkLoginStatus() {
    const userInfo = store.getUserInfo();
    if (userInfo && userInfo.userId) {
      this.setData({ 
        isLoggedIn: true, 
        showLoginModal: false,
        userId: userInfo.userId,
      });
      this.setCurrentDate();
      // 初始化过滤分类（去掉'全部'）
      this.setData({
        filteredCategories: this.data.categories.slice(1)
      });
      this.loadIngredients();
    } else {
      
      wx.showToast({
        title: '请先登录',
        icon: 'none'
      });
      this.setData({ 
        isLoggedIn: false, 
        showLoginModal: true,
        ingredients: [] // 清空食材列表
      });
      
    }
  },
// 处理强制登录关闭事件
  handleForceLoginClose() {
    // 再次检查登录状态，确保最新状态
    const userInfo = store.getUserInfo();
    if (userInfo && userInfo.userId) {
      this.setData({ isLoggedIn: true });
      return;
    }
    
    // 用户尝试在未登录状态下关闭登录框
    wx.showModal({
      title: '需要登录',
      content: '冰箱管理功能需要登录后才能使用',
      cancelText: '返回首页',
      confirmText: '继续登录',
      success: (res) => {
        if (res.cancel) {
          // 用户选择返回，则导航回首页
          wx.switchTab({
            url: '/pages/index/index'
          });
        }
        // 用户选择继续登录，保持模态框打开状态
      }
    });
  },
  // 登录成功回调
  onLoginSuccess(e) {
    // 获取登录成功返回的用户信息
    const userInfo = e.detail;
    
    this.setData({ 
      showLoginModal: false,
      isLoggedIn: true,  // 立即更新登录状态
      userId: userInfo.userId
    });
    // 登录成功后加载数据
    this.checkLoginStatus();
    wx.showToast({
      title: '登录成功',
      icon: 'success'
    });
  },

  // 关闭登录模态框
  closeLoginModal() {
    this.setData({ showLoginModal: false });
  },

  // 设置当前日期
  setCurrentDate() {
    const date = new Date();
    const year = date.getFullYear();
    const month = (date.getMonth() + 1).toString().padStart(2, '0');
    const day = date.getDate().toString().padStart(2, '0');
    this.setData({
      currentDate: `${year}-${month}-${day}`
    });
  },

  calculateDaysToExpiry(expiryDate) {
    const currentDate = new Date(this.data.currentDate);
    const expiry = new Date(expiryDate);
    const timeDiff = expiry - currentDate;
    const days = Math.ceil(timeDiff / (1000 * 60 * 60 * 24));

    // 如果食材已经过期，则返回0，并标记为已过期
    if (days < 0) {
      return 0; // 返回0代表已过期
    }
    return days;
  },
  // 加载食材列表
  loadIngredients(categoryId = null) {
    if (!this.data.isLoggedIn || !this.data.hasMore) return;
    const params = {
      current: this.data.current,
      pageSize: this.data.pageSize,
      userId: this.data.userId
    };

    if (categoryId !== null) {
      params.categoryId = categoryId;
    }

    getFridgeIngredients(params)
      .then(res => {
        if (res.success) {
          const newIngredients = res.data.records.map(item => {
            const daysToExpiry = this.calculateDaysToExpiry(item.expiryDate);
            let expiryColor = 'green'; // 默认颜色为绿色
            let displayName = item.ingredient;

            // 如果已过期，设置深灰色并显示为"已过期"
            if (daysToExpiry === 0) {
              expiryColor = 'gray'; // 已过期：深灰色
            } else if (daysToExpiry === 1) {
              expiryColor = 'red'; // 1天过期：红色
            } else if (daysToExpiry <= 3) {
              expiryColor = 'orange'; // 3天以内过期：橙色
            } else if (daysToExpiry <= 7) {
              expiryColor = 'yellow'; // 7天以内过期：黄色
            }

            // 格式化过期时间
            const formattedExpiryDate = this.formatDate(item.expiryDate);

            return {
              itemId: item.itemId, // 后端的 itemId 映射到前端的 id
              name: displayName, // 显示为"已过期"或正常名称
              categoryId: item.categoryId, // 后端的 categoryId
              quantity: item.quantity, // 后端的 quantity
              expiryDate: item.expiryDate, // 保留原始过期时间
              formattedExpiryDate: formattedExpiryDate, // 添加格式化后的过期时间
              daysToExpiry: daysToExpiry,
              expiryColor: expiryColor // 传递颜色信息
            };
          });

          this.setData({
            ingredients: this.data.ingredients.concat(newIngredients),
            hasMore: newIngredients.length === this.data.pageSize,
            current: this.data.current + 1
          });

          // 只有在第一页数据加载完成且未显示过提醒时才检查过期
          if (this.data.current === 2 && !this.data.hasShownExpiryAlert) {
            this.checkExpiry();
          }
        }
      })
      .catch(err => {
        console.error('获取食材列表失败', err);
      });
  },

  // 添加格式化日期的方法
  formatDate(timestamp) {
    if (!timestamp) return '';
    
    // 如果是时间戳（数字），转换为日期对象
    const date = new Date(typeof timestamp === 'number' ? timestamp : timestamp);
    
    const year = date.getFullYear();
    const month = (date.getMonth() + 1).toString().padStart(2, '0');
    const day = date.getDate().toString().padStart(2, '0');
    
    return `${year}-${month}-${day}`;
  },

  // 修改 checkExpiry 方法，合并即将过期的食材并使用 wx.showModal 弹出提示框
  checkExpiry() {
    // 如果已经显示过提醒，则不再显示
    if (this.data.hasShownExpiryAlert) {
      return;
    }
    const expiredItems = []; // 存储已过期的食材名称
    const expiringItems = []; // 存储即将过期的食材名称
    
    // 遍历食材列表，分别找出已过期和即将过期的食材
    this.data.ingredients.forEach(ingredient => {
      if (ingredient.daysToExpiry === 0) {
        expiredItems.push(ingredient.name);
      }else if (ingredient.daysToExpiry <= 3) {
        expiringItems.push(ingredient.name);
      }
    });
    // 构建提醒消息
    let message = '';

    if (expiredItems.length > 0) {
      message += `${expiredItems.join('、')} 已经过期，请及时处理！\n\t`;
    }
    
    if (expiringItems.length > 0) {
      message += `${expiringItems.join('、')} 即将在1~3天内过期，请尽快食用。`;
    }

    // 如果有需要提醒的食材，进行弹窗提醒
    if (message) {
      wx.showModal({
        title: '食材过期提醒',
        content: message,
        showCancel: false, // 只显示确认按钮
        confirmText: '我知道了',
        success: res => {
          if (res.confirm) {
            console.log('用户点击了确认');
          }
        }
      });

      // 标记已经显示过提醒
      this.setData({
        hasShownExpiryAlert: true
      });
      
      // 将提醒状态存储到本地，确保本次小程序会话中不再提醒
      wx.setStorageSync('expiryAlertShown', true);
    }
  },

  // 切换分类
  switchCategory(event) {
    const category = event.currentTarget.dataset.category;
    const categoryIndex = this.data.categories.indexOf(category);
    const categoryId = categoryIndex > 0 ? categoryIndex : null; // '全部'对应null

    this.setData({
      selectedCategory: category,
      current: 1,
      ingredients: [],
      hasMore: true
      // 不重置 hasShownExpiryAlert，保持提醒状态
    });
    this.loadIngredients(categoryId);
  },


  // 根据分类过滤食材
  filterIngredientsByCategory(category) {
    if (category === '全部') {
      this.loadIngredients();
    } else {
      getFridgeIngredients({
          category,
          current: this.data.current,
          pageSize: this.data.pageSize
        })
        .then(res => {
          if (res.success) {
            const newIngredients = res.data.records.map(item => ({
              id: item.itemId, // 后端的 itemId 映射到前端的 id
              name: item.ingredient, // 后端的 ingredient 映射到前端的 name
              categoryId: item.categoryId, // 后端的 categoryId
              quantity: item.quantity, // 后端的 quantity
              expiryDate: item.expiryDate.split('T')[0], // 后端的 expiryDate 格式化
              daysToExpiry: this.calculateDaysToExpiry(item.expiryDate)
            }));

            this.setData({
              ingredients: this.data.ingredients.concat(newIngredients),
              hasMore: newIngredients.length === this.data.pageSize,
              current: this.data.current + 1
            });
          }
        })
        .catch(err => {
          console.error('获取分类食材失败', err);
        });
    }
  },

  // 显示添加食材模态框
  showAddIngredient() {
    app.checkLoginStatus();
    this.setData({
      showAddIngredientModal: true
    });
  },

  // 隐藏添加食材模态框
  hideAddIngredient() {
    this.setData({
      showAddIngredientModal: false,
      // 重置添加食材的表单数据
      newIngredient: {
        name: '',
        category: '',
        categoryIndex: 0, // 默认选中第一个分类
        expiryDate: '',
        quantity: ''
      }
    });
  },

  // 添加食材
  addIngredient() {
    const {
      newIngredient,
      userId,
      selectedCategory
    } = this.data;

    // 进行必填项校验
    if (!newIngredient.name || !newIngredient.category || !newIngredient.expiryDate || !newIngredient.quantity) {
      wx.showToast({
        title: '请输入完整的食材信息',
        icon: 'none'
      });
      return;
    }

    const ingredientData = {
      userId,
      ingredient: newIngredient.name,
      categoryId: +newIngredient.categoryIndex + 1, // 假设分类ID从1开始
      quantity: newIngredient.quantity,
      expiryDate: newIngredient.expiryDate
    };

    // 调用封装的API接口
    addIngredient(ingredientData)
      .then(res => {
        if (res.success) {
          const categoryIndex = this.data.categories.indexOf(selectedCategory);
          const categoryId = categoryIndex > 0 ? categoryIndex : null; // '全部'对应null
          this.setData({
            current: 1,
            ingredients: [],
            hasMore: true
          });
          this.loadIngredients(categoryId); // 使用当前选中的分类ID重新加载食材列表
          this.hideAddIngredient(); // 关闭模态框并重置表单数据
          wx.showToast({
            title: '食材添加成功',
            icon: 'success'
          });
        } else {
          wx.showToast({
            title: '添加食材失败',
            icon: 'none'
          });
        }
      })
      .catch(err => {
        console.error('添加食材失败', err);
        wx.showToast({
          title: '添加食材失败',
          icon: 'none'
        });
      });
  },

  // 处理输入变化
  handleInputChange(event) {
    const {
      field
    } = event.currentTarget.dataset;
    this.setData({
      [`newIngredient.${field}`]: event.detail.value
    });
  },

  // 处理日期变化
  handleDateChange(event) {
    const selectedDate = event.detail.value;
    const currentDate = this.data.currentDate;

    if (selectedDate < currentDate) {
      wx.showToast({
        title: '不能选择过去的日期',
        icon: 'none'
      });
      this.setData({
        'newIngredient.expiryDate': ''
      });
    } else {
      this.setData({
        'newIngredient.expiryDate': selectedDate
      });
    }
  },

  // 修改分类选择处理逻辑
  handleCategoryChange(event) {
    const index = event.detail.value;
    const category = this.data.filteredCategories[index]; // 直接使用过滤后的分类数组
    this.setData({
      'newIngredient.category': category,
      'newIngredient.categoryIndex': index
    });
  },
  handleLongPress(event) {
    app.checkLoginStatus();
    const ingredient = event.currentTarget.dataset.item; // 获取长按目标食材的数据
    console.log("ingredient", ingredient);

    this.setData({
      editIngredient: {
        ...ingredient, // 将选中的食材信息设置到 `editIngredient` 中
        category: this.data.categories[ingredient.categoryId], // 更新分类名
        categoryIndex: ingredient.categoryId - 1,
        // 确保使用格式化后的日期
        expiryDate: this.formatDate(ingredient.expiryDate)
      },
      showEditIngredientModal: true // 显示编辑模态框
    });
  },


  hideEditIngredient() {
    this.setData({
      showEditIngredientModal: false
    });
  },

  handleEditInputChange(event) {
    const {
      field
    } = event.currentTarget.dataset;
    this.setData({
      [`editIngredient.${field}`]: event.detail.value
    });
  },

  handleEditCategoryChange(event) {
    this.setData({
      'editIngredient.categoryIndex': event.detail.value,
      'editIngredient.category': this.data.filteredCategories[event.detail.value]
    });
  },

  handleEditDateChange(event) {
    this.setData({
      'editIngredient.expiryDate': event.detail.value
    });
  },

  updateIngredient(event) {
    console.log("event", event);
    const {
      editIngredient
    } = this.data;

    if (!editIngredient.name || !editIngredient.category || !editIngredient.expiryDate || !editIngredient.quantity) {
      wx.showToast({
        title: '请输入完整的食材信息',
        icon: 'none'
      });
      return;
    }

    const ingredientData = {
      itemId: editIngredient.itemId, // 使用 itemId 更新食材
      ingredient: editIngredient.name,
      categoryId: +editIngredient.categoryIndex + 1, // 假设分类ID从1开始
      quantity: editIngredient.quantity,
      expiryDate: editIngredient.expiryDate
    };
    updateIngredient(ingredientData)
    .then(res => {
      if (res.success) {
        this.setData({
          showEditIngredientModal: false, // 关闭编辑模态框
          current: 1, // 重置当前页码
          ingredients: [], // 清空当前食材列表
          hasMore: true // 重置是否有更多数据的标志
        });
        this.loadIngredients(); // 重新加载食材列表
      }
    })
    .catch(err => {
      console.error('更新食材失败', err);
    });
    
  },
  confirmDelete() {
    const itemId = this.data.editIngredient.itemId;
    wx.showModal({
      title: '确认删除',
      content: '您确定要删除这个食材吗？',
      success: (res) => {
        if (res.confirm) {
          this.deleteIngredient(itemId);
        }
      }
    });
  },

  deleteIngredient(itemId) {
    // 假设有一个deleteIngredient API
    deleteIngredient(itemId)
      .then(res => {
        if (res.success) {
          wx.showToast({
            title: '删除成功',
            icon: 'success'
          });
          const categoryIndex = this.data.categories.indexOf(this.data.selectedCategory);
          const categoryId = categoryIndex > 0 ? categoryIndex : null; // '全部'对应null
          this.setData({
            current: 1,
            ingredients: [],
            hasMore: true
          });
          this.loadIngredients(categoryId); // 重新加载当前分类的食材列表
          this.hideEditIngredient();
        } else {
          wx.showToast({
            title: '删除失败',
            icon: 'none'
          });
        }
      })
      .catch(err => {
        console.error('删除食材失败', err);
        wx.showToast({
          title: '删除失败',
          icon: 'none'
        });
      });
  },
});